home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / varia / grammar1.lha / c++grammar1.1 / skelgrph.c < prev   
Encoding:
C/C++ Source or Header  |  1990-06-07  |  12.4 KB  |  403 lines
  1. #include "defs.h"
  2.  
  3. /*  The three line banner used here should be replaced with a one line    */
  4. /*  #ident directive if the target C compiler supports #ident        */
  5. /*  directives.                                */
  6. /*                                    */
  7. /*  If the skeleton is changed, the banner should be changed so that    */
  8. /*  the altered version can easily be distinguished from the original.    */
  9.  
  10. char *banner[] =
  11. {
  12.     "#ifndef lint",
  13.     "char yysccsid[] = \"@(#)yaccpar    1.4 (Berkeley) 02/25/90 \\n\\",
  14.     " Modified 5/2/90 by J. Roskind to support graphic debugging modes\";",
  15.     "#endif",
  16.     0
  17. };
  18.  
  19.  
  20. char *header[] =
  21. {
  22.     "#define yyclearin (yychar=(-1))",
  23.     "#define yyerrok (yyerrflag=0)",
  24.     "#ifndef YYSTACKSIZE",
  25.     "#ifdef YYMAXDEPTH",
  26.     "#define YYSTACKSIZE YYMAXDEPTH",
  27.     "#else",
  28.     "#define YYSTACKSIZE 300",
  29.     "#endif",
  30.     "#endif",
  31.     "int yydebug;",
  32.     "int yynerrs;",
  33.     "int yyerrflag;",
  34.     "int yychar;",
  35.     "short *yyssp;",
  36.     "YYSTYPE *yyvsp;",
  37.     "YYSTYPE yyval;",
  38.     "YYSTYPE yylval;",
  39.     "#define yystacksize YYSTACKSIZE",
  40.     "short yyss[YYSTACKSIZE];",
  41.     "YYSTYPE yyvs[YYSTACKSIZE];",
  42.     0
  43. };
  44.  
  45.  
  46. char *body[] =
  47. {
  48.     "#define YYABORT goto yyabort",
  49.     "#define YYACCEPT goto yyaccept",
  50.     "#define YYERROR goto yyerrlab",
  51.     "#ifdef YYDEBUG",
  52.     "#ifndef YYDEBUG_LEXER_TEXT /* pointer to the text isolated by the lexer*/",
  53.     "#define YYDEBUG_LEXER_TEXT \"YYDEBUG_LEXER_TEXT not defined\"",
  54.     "#endif",
  55.     "#ifndef YYDEBUG_INDENT_STRING",
  56.     "#define YYDEBUG_INDENT_STRING  \"|       \"",
  57.     "#endif",
  58.     "#ifndef YYDEBUG_REDUCE_STRING",
  59.     "#define YYDEBUG_REDUCE_STRING  \"+-------\"",
  60.     "#endif",
  61.     "#ifndef YYDEBUG_INDENT",
  62.     "YYDEBUG_INDENT(yyindent)",
  63.     "int yyindent;",
  64.     "{",
  65.     "    while(yyindent-- > 0)",
  66.     "        printf(\"%s\", YYDEBUG_INDENT_STRING);",
  67.     "}",
  68.     "#endif /* YYDEBUG_INDENT */",
  69.     "#ifndef YYDEBUG_REDUCE",
  70.     "YYDEBUG_REDUCE(yynew_state, yyrule_num, yyrule_string, yynew_indent, \\",
  71.     "yyrhs_count)",
  72.     "int yynew_state;",
  73.     "int yyrule_num;",
  74.     "char * yyrule_string;",
  75.     "int yynew_indent;",
  76.     "int yyrhs_count;",
  77.     "{",
  78.     "    if (1 < yyrhs_count)",
  79.     "    {  /* draw the graphics for the reduction */",
  80.     "        YYDEBUG_INDENT(yynew_indent);",
  81.     "        while(1 < yyrhs_count--)",
  82.     "            printf(\"%s\", YYDEBUG_REDUCE_STRING);",
  83.     "        putchar('+'); /* left rotated L would look nice */",
  84.     "        putchar('\\n');",
  85.     "        YYDEBUG_INDENT(yynew_indent);",
  86.     "        putchar('|'); /* down arrow would look nice */",
  87.     "        putchar('\\n');",
  88.     "    }",
  89.     "    YYDEBUG_INDENT(yynew_indent);",
  90.     "    /* Only print the resulting token name */",
  91.     "    while (*yyrule_string && ' ' != *yyrule_string)",
  92.     "        putchar(*yyrule_string++);",
  93.     "    putchar('\\n');",
  94.     "}",
  95.     "#endif /* YYDEBUG_REDUCE */",
  96.     "#ifndef YYDEBUG_SHIFT_LEXEME",
  97.     "YYDEBUG_SHIFT_LEXEME(yyold_state, yynew_state, yytoken_string, yynew_indent)",
  98.     "int yyold_state;",
  99.     "int yynew_state;",
  100.     "char * yytoken_string;",
  101.     "int yynew_indent;",
  102.     "{",
  103.     "    YYDEBUG_INDENT(yynew_indent);",
  104.     "    printf(\"%s <-- `%s'\\n\", yytoken_string, YYDEBUG_LEXER_TEXT);",
  105.     "}",
  106.     "#endif /*  YYDEBUG_SHIFT_LEXEME */",
  107.     "#ifndef YYDEBUG_LOOK_AHEAD",
  108.     "YYDEBUG_LOOK_AHEAD(yynew_state, yytoken_num, yytoken_string, yyindent)",
  109.     "int yynew_state;",
  110.     "int yytoken_num;",
  111.     "char * yytoken_string;",
  112.     "int yyindent;",
  113.     "{",
  114.     "    YYDEBUG_INDENT(yyindent);",
  115.     "    printf(\"          .... look ahead at %s   `%s'\\n\",",
  116.     "           yytoken_string,",
  117.     "           (0 == yytoken_num)? \"\\0\": YYDEBUG_LEXER_TEXT);",
  118.     "}",
  119.     "#endif /* YYDEBUG_LOOK_AHEAD */",
  120.     "#ifndef YYDEBUG_DISCARD_STATE",
  121.     "YYDEBUG_DISCARD_STATE(yynew_state, yyindent)",
  122.     "int yynew_state;",
  123.     "int yyindent;",
  124.     "{",
  125.     "    if (0 < yyindent)",
  126.     "    {  /* draw the graphics for the reduction */",
  127.     "        YYDEBUG_INDENT(yyindent-1);",
  128.     "        printf(\"%s\", YYDEBUG_REDUCE_STRING);",
  129.     "        putchar('+'); /* left rotated L would look nice */",
  130.     "        printf(\"  discarding state\\n\");",
  131.     "        YYDEBUG_INDENT(yyindent-1);",
  132.     "        putchar('|'); /* down arrow would look nice */",
  133.     "        putchar('\\n');",
  134.     "    }",
  135.     "    else",
  136.     "    {",
  137.     "        if (0 == yyindent)",
  138.     "            printf(\"discarding state\\n\");",
  139.     "        else",
  140.     "            printf(\"no more states to discard: parser will abort\\n\");",
  141.     "    }",
  142.     "}",
  143.     "#endif /* YYDEBUG_DISCARD_STATE */",
  144.     "#ifndef YYDEBUG_DISCARD_TOKEN",
  145.     "YYDEBUG_DISCARD_TOKEN(yynew_state, yytoken_num, yytoken_string, yyindent)",
  146.     "int yynew_state;",
  147.     "int yytoken_num;",
  148.     "char * yytoken_string;",
  149.     "int yyindent;",
  150.     "{",
  151.     "    YYDEBUG_INDENT(yyindent);",
  152.     "    printf(\"discarding token %s\\n\", yytoken_string);",
  153.     "}",
  154.     "#endif /* YYDEBUG_DISCARD_TOKEN */",
  155.     "#ifndef YYDEBUG_SHIFT_ERROR_LEXEME",
  156.     "YYDEBUG_SHIFT_ERROR_LEXEME(yyold_state, yynew_state, yyindent)",
  157.     "int yyold_state;",
  158.     "int yynew_state;",
  159.     "int yyindent;",
  160.     "{",
  161.     "    YYDEBUG_INDENT(yyindent);",
  162.     "    printf(\"error\\n\");",
  163.     "}",
  164.     "#endif /* YYDEBUG_SHIFT_ERROR_LEXEME */",
  165.     "#endif /* YYDEBUG */",
  166.     "int",
  167.     "yyparse()",
  168.     "{",
  169.     "    register int yym, yyn, yystate;",
  170.     "#if YYDEBUG",
  171.     "    register char *yys;",
  172.     "    extern char *getenv();",
  173.     "",
  174.     "    if (yys = getenv(\"YYDEBUG\"))",
  175.     "    {",
  176.     "        yyn = *yys;",
  177.     "        if (yyn >= '0' && yyn <= '9')",
  178.     "            yydebug = yyn - '0';",
  179.     "    }",
  180.     "#endif",
  181.     "",
  182.     "    yynerrs = 0;",
  183.     "    yyerrflag = 0;",
  184.     "    yychar = (-1);",
  185.     "",
  186.     "    yyssp = yyss;",
  187.     "    yyvsp = yyvs;",
  188.     "    *yyssp = yystate = 0;",
  189.     "",
  190.     "yyloop:",
  191.     "    if (yyn = yydefred[yystate]) goto yyreduce;",
  192.     "    if (yychar < 0)",
  193.     "    {",
  194.     "        if ((yychar = yylex()) < 0) yychar = 0;",
  195.     "#if YYDEBUG",
  196.     "        if (yydebug)",
  197.     "        {",
  198.     "            yys = 0;",
  199.     "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  200.     "            if (!yys) yys = \"illegal-symbol\";",
  201.     "            if (5 > yydebug)",
  202.     "                printf(\"yydebug: state %d, reading %d (%s)\\n\", yystate,",
  203.     "                        yychar, yys);",
  204.     "            else",
  205.     "                YYDEBUG_LOOK_AHEAD(yystate, yychar, yys, yyssp-yyss);",
  206.     "        }",
  207.     "#endif",
  208.     "    }",
  209.     "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
  210.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
  211.     "    {",
  212.     "#if YYDEBUG",
  213.     "        if (yydebug)",
  214.     "            if (5 > yydebug)",
  215.     "                printf(\"yydebug: state %d, shifting to state %d\\n\",",
  216.     "                        yystate, yytable[yyn]);",
  217.     "            else",
  218.     "                YYDEBUG_SHIFT_LEXEME(yystate, yytable[yyn], yys, yyssp-yyss);",
  219.     "#endif",
  220.     "        if (yyssp >= yyss + yystacksize - 1)",
  221.     "        {",
  222.     "            goto yyoverflow;",
  223.     "        }",
  224.     "        *++yyssp = yystate = yytable[yyn];",
  225.     "        *++yyvsp = yylval;",
  226.     "        yychar = (-1);",
  227.     "        if (yyerrflag > 0)  --yyerrflag;",
  228.     "        goto yyloop;",
  229.     "    }",
  230.     "    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&",
  231.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
  232.     "    {",
  233.     "        yyn = yytable[yyn];",
  234.     "        goto yyreduce;",
  235.     "    }",
  236.     "    if (yyerrflag) goto yyinrecovery;",
  237.     "#ifdef lint",
  238.     "    goto yynewerror;",
  239.     "#endif",
  240.     "yynewerror:",
  241.     "    yyerror(\"syntax error\");",
  242.     "#ifdef lint",
  243.     "    goto yyerrlab;",
  244.     "#endif",
  245.     "yyerrlab:",
  246.     "    ++yynerrs;",
  247.     "yyinrecovery:",
  248.     "    if (yyerrflag < 3)",
  249.     "    {",
  250.     "        yyerrflag = 3;",
  251.     "        for (;;)",
  252.     "        {",
  253.     "            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&",
  254.     "                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)",
  255.     "            {",
  256.     "#if YYDEBUG",
  257.     "                if (yydebug)",
  258.     "                    if (5 > yydebug)",
  259.     "                        printf(\"yydebug: state %d, error recovery shifting\\",
  260.     " to state %d\\n\", *yyssp, yytable[yyn]);",
  261.     "                    else",
  262.     "                        YYDEBUG_SHIFT_ERROR_LEXEME(*yyssp, yytable[yyn], yyssp-yyss);",
  263.     "#endif",
  264.     "                if (yyssp >= yyss + yystacksize - 1)",
  265.     "                {",
  266.     "                    goto yyoverflow;",
  267.     "                }",
  268.     "                *++yyssp = yystate = yytable[yyn];",
  269.     "                *++yyvsp = yylval;",
  270.     "                goto yyloop;",
  271.     "            }",
  272.     "            else",
  273.     "            {",
  274.     "#if YYDEBUG",
  275.     "                if (yydebug)",
  276.     "                    if (5 > yydebug)",
  277.     "                        printf(\"yydebug: error recovery discarding state %d\
  278. \\n\",",
  279.     "                            *yyssp);",
  280.     "                    else",
  281.     "                        YYDEBUG_DISCARD_STATE(*yyssp, yyssp-yyss-1);",
  282.     "#endif",
  283.     "                if (yyssp <= yyss) goto yyabort;",
  284.     "                --yyssp;",
  285.     "                --yyvsp;",
  286.     "            }",
  287.     "        }",
  288.     "    }",
  289.     "    else",
  290.     "    {",
  291.     "        if (yychar == 0) goto yyabort;",
  292.     "#if YYDEBUG",
  293.     "        if (yydebug)",
  294.     "        {",
  295.     "            yys = 0;",
  296.     "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  297.     "            if (!yys) yys = \"illegal-symbol\";",
  298.  
  299.     "            if (5 > yydebug)",
  300.     "                printf(\"yydebug: state %d, error recovery discards token\
  301.  %d (%s)\\n\",",
  302.     "                    yystate, yychar, yys);",
  303.     "            else ",
  304.     "                YYDEBUG_DISCARD_TOKEN(yystate, yychar, yys, yyssp-yyss);",
  305.     "        }",
  306.     "#endif",
  307.     "        yychar = (-1);",
  308.     "        goto yyloop;",
  309.     "    }",
  310.     "yyreduce:",
  311.     "    yym = yylen[yyn];",
  312.     "    yyval = yyvsp[1-yym];",
  313.     "#if YYDEBUG",
  314.     "    if (yydebug)",
  315.     "        if (5 > yydebug)",
  316.     "            printf(\"yydebug: state %d, reducing by rule %d (%s)\\n\",",
  317.     "                    yystate, yyn, yyrule[yyn]);",
  318.     "        else",
  319.     "            YYDEBUG_REDUCE(yystate, yyn, yyrule[yyn], yyssp-yyss-yym, yym);",
  320.     "#endif",
  321.     "    switch (yyn)",
  322.     "    {",
  323.     0
  324. };
  325.  
  326.  
  327. char *trailer[] =
  328. {
  329.     "    }",
  330.     "    yyssp -= yym;",
  331.     "    yystate = *yyssp;",
  332.     "    yyvsp -= yym;",
  333.     "    yym = yylhs[yyn];",
  334.     "    if (yystate == 0 && yym == 0)",
  335.     "    {",
  336.     "#ifdef YYDEBUG",
  337.     "        if (5 > yydebug)",
  338.     "            printf(\"yydebug: after reduction, shifting from state 0 to\\",
  339.     " state %d\\n\", YYFINAL);",
  340.     "#endif",
  341.     "        yystate = YYFINAL;",
  342.     "        *++yyssp = YYFINAL;",
  343.     "        *++yyvsp = yyval;",
  344.     "        if (yychar < 0)",
  345.     "        {",
  346.     "            if ((yychar = yylex()) < 0) yychar = 0;",
  347.     "#if YYDEBUG",
  348.     "            if (yydebug)",
  349.     "            {",
  350.     "                yys = 0;",
  351.     "                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
  352.     "                if (!yys) yys = \"illegal-symbol\";",
  353.     "                if (5 > yydebug)",
  354.     "                    printf(\"yydebug: state %d, reading %d (%s)\\n\",",
  355.     "                        YYFINAL, yychar, yys);",
  356.     "                else",
  357.     "                    YYDEBUG_LOOK_AHEAD(YYFINAL, yychar, yys, yyssp-yyss);",
  358.     "            }",
  359.     "#endif",
  360.     "        }",
  361.     "        if (yychar == 0) goto yyaccept;",
  362.     "        goto yyloop;",
  363.     "    }",
  364.     "    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
  365.     "            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)",
  366.     "        yystate = yytable[yyn];",
  367.     "    else",
  368.     "        yystate = yydgoto[yym];",
  369.     "#ifdef YYDEBUG",
  370.     "    if (5 > yydebug)",
  371.     "        printf(\"yydebug: after reduction, shifting from state %d \\",
  372.     "to state %d\\n\", *yyssp, yystate);",
  373.     "#endif",
  374.     "    if (yyssp >= yyss + yystacksize - 1)",
  375.     "    {",
  376.     "        goto yyoverflow;",
  377.     "    }",
  378.     "    *++yyssp = yystate;",
  379.     "    *++yyvsp = yyval;",
  380.     "    goto yyloop;",
  381.     "yyoverflow:",
  382.     "    yyerror(\"yacc stack overflow\");",
  383.     "yyabort:",
  384.     "    return (1);",
  385.     "yyaccept:",
  386.     "    return (0);",
  387.     "}",
  388.     0
  389. };
  390.  
  391.  
  392. write_section(section)
  393. char *section[];
  394. {
  395.     register int i;
  396.  
  397.     for (i = 0; section[i]; ++i)
  398.     {
  399.     ++outline;
  400.     fprintf(output_file, "%s\n", section[i]);
  401.     }
  402. }
  403.